home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / include / bits / libc-lock.h < prev    next >
C/C++ Source or Header  |  2008-09-29  |  22KB  |  586 lines
  1. /* libc-internal interface for mutex locks.  NPTL version.
  2.    Copyright (C) 1996-2003, 2005, 2007 Free Software Foundation, Inc.
  3.    This file is part of the GNU C Library.
  4.  
  5.    The GNU C Library is free software; you can redistribute it and/or
  6.    modify it under the terms of the GNU Lesser General Public License as
  7.    published by the Free Software Foundation; either version 2.1 of the
  8.    License, or (at your option) any later version.
  9.  
  10.    The GNU C Library is distributed in the hope that it will be useful,
  11.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.    Lesser General Public License for more details.
  14.  
  15.    You should have received a copy of the GNU Lesser General Public
  16.    License along with the GNU C Library; see the file COPYING.LIB.  If not,
  17.    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18.    Boston, MA 02111-1307, USA.  */
  19.  
  20. #ifndef _BITS_LIBC_LOCK_H
  21. #define _BITS_LIBC_LOCK_H 1
  22.  
  23. #include <pthread.h>
  24. #define __need_NULL
  25. #include <stddef.h>
  26.  
  27.  
  28. /* Fortunately Linux now has a mean to do locking which is realtime
  29.    safe without the aid of the thread library.  We also need no fancy
  30.    options like error checking mutexes etc.  We only need simple
  31.    locks, maybe recursive.  This can be easily and cheaply implemented
  32.    using futexes.  We will use them everywhere except in ld.so since
  33.    ld.so might be used on old kernels with a different libc.so.  */
  34. #ifdef _LIBC
  35. # include <lowlevellock.h>
  36. # include <tls.h>
  37. # include <pthread-functions.h>
  38. #endif
  39.  
  40. /* Mutex type.  */
  41. #if defined _LIBC || defined _IO_MTSAFE_IO
  42. # if (defined NOT_IN_libc && !defined IS_IN_libpthread) || !defined _LIBC
  43. typedef pthread_mutex_t __libc_lock_t;
  44. typedef struct { pthread_mutex_t mutex; } __libc_lock_recursive_t;
  45. # else
  46. typedef int __libc_lock_t;
  47. typedef struct { int lock; int cnt; void *owner; } __libc_lock_recursive_t;
  48. # endif
  49. typedef struct { pthread_mutex_t mutex; } __rtld_lock_recursive_t;
  50. # ifdef __USE_UNIX98
  51. typedef pthread_rwlock_t __libc_rwlock_t;
  52. # else
  53. typedef struct __libc_rwlock_opaque__ __libc_rwlock_t;
  54. # endif
  55. #else
  56. typedef struct __libc_lock_opaque__ __libc_lock_t;
  57. typedef struct __libc_lock_recursive_opaque__ __libc_lock_recursive_t;
  58. typedef struct __libc_rwlock_opaque__ __libc_rwlock_t;
  59. #endif
  60.  
  61. /* Type for key to thread-specific data.  */
  62. typedef pthread_key_t __libc_key_t;
  63.  
  64. /* Define a lock variable NAME with storage class CLASS.  The lock must be
  65.    initialized with __libc_lock_init before it can be used (or define it
  66.    with __libc_lock_define_initialized, below).  Use `extern' for CLASS to
  67.    declare a lock defined in another module.  In public structure
  68.    definitions you must use a pointer to the lock structure (i.e., NAME
  69.    begins with a `*'), because its storage size will not be known outside
  70.    of libc.  */
  71. #define __libc_lock_define(CLASS,NAME) \
  72.   CLASS __libc_lock_t NAME;
  73. #define __libc_rwlock_define(CLASS,NAME) \
  74.   CLASS __libc_rwlock_t NAME;
  75. #define __libc_lock_define_recursive(CLASS,NAME) \
  76.   CLASS __libc_lock_recursive_t NAME;
  77. #define __rtld_lock_define_recursive(CLASS,NAME) \
  78.   CLASS __rtld_lock_recursive_t NAME;
  79.  
  80. /* Define an initialized lock variable NAME with storage class CLASS.
  81.  
  82.    For the C library we take a deeper look at the initializer.  For
  83.    this implementation all fields are initialized to zero.  Therefore
  84.    we don't initialize the variable which allows putting it into the
  85.    BSS section.  (Except on PA-RISC and other odd architectures, where
  86.    initialized locks must be set to one due to the lack of normal
  87.    atomic operations.) */
  88.  
  89. #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
  90. # if LLL_LOCK_INITIALIZER == 0
  91. #  define __libc_lock_define_initialized(CLASS,NAME) \
  92.   CLASS __libc_lock_t NAME;
  93. # else
  94. #  define __libc_lock_define_initialized(CLASS,NAME) \
  95.   CLASS __libc_lock_t NAME = LLL_LOCK_INITIALIZER;
  96. # endif
  97. #else
  98. # if __LT_SPINLOCK_INIT == 0
  99. #  define __libc_lock_define_initialized(CLASS,NAME) \
  100.   CLASS __libc_lock_t NAME;
  101. # else
  102. #  define __libc_lock_define_initialized(CLASS,NAME) \
  103.   CLASS __libc_lock_t NAME = PTHREAD_MUTEX_INITIALIZER;
  104. # endif
  105. #endif
  106.  
  107. #define __libc_rwlock_define_initialized(CLASS,NAME) \
  108.   CLASS __libc_rwlock_t NAME = PTHREAD_RWLOCK_INITIALIZER;
  109.  
  110. /* Define an initialized recursive lock variable NAME with storage
  111.    class CLASS.  */
  112. #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
  113. # if LLL_LOCK_INITIALIZER == 0
  114. #  define __libc_lock_define_initialized_recursive(CLASS,NAME) \
  115.   CLASS __libc_lock_recursive_t NAME;
  116. # else
  117. #  define __libc_lock_define_initialized_recursive(CLASS,NAME) \
  118.   CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER;
  119. # endif
  120. # define _LIBC_LOCK_RECURSIVE_INITIALIZER \
  121.   { LLL_LOCK_INITIALIZER, 0, NULL }
  122. #else
  123. # define __libc_lock_define_initialized_recursive(CLASS,NAME) \
  124.   CLASS __libc_lock_recursive_t NAME = _LIBC_LOCK_RECURSIVE_INITIALIZER;
  125. # define _LIBC_LOCK_RECURSIVE_INITIALIZER \
  126.   {PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP}
  127. #endif
  128.  
  129. #define __rtld_lock_define_initialized_recursive(CLASS,NAME) \
  130.   CLASS __rtld_lock_recursive_t NAME = _RTLD_LOCK_RECURSIVE_INITIALIZER;
  131. #define _RTLD_LOCK_RECURSIVE_INITIALIZER \
  132.   {PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP}
  133.  
  134. #define __rtld_lock_initialize(NAME) \
  135.   (void) ((NAME) = (__rtld_lock_recursive_t) _RTLD_LOCK_RECURSIVE_INITIALIZER)
  136.  
  137. /* If we check for a weakly referenced symbol and then perform a
  138.    normal jump to it te code generated for some platforms in case of
  139.    PIC is unnecessarily slow.  What would happen is that the function
  140.    is first referenced as data and then it is called indirectly
  141.    through the PLT.  We can make this a direct jump.  */
  142. #ifdef __PIC__
  143. # define __libc_maybe_call(FUNC, ARGS, ELSE) \
  144.   (__extension__ ({ __typeof (FUNC) *_fn = (FUNC); \
  145.                     _fn != NULL ? (*_fn) ARGS : ELSE; }))
  146. #else
  147. # define __libc_maybe_call(FUNC, ARGS, ELSE) \
  148.   (FUNC != NULL ? FUNC ARGS : ELSE)
  149. #endif
  150.  
  151. /* Call thread functions through the function pointer table.  */
  152. #if defined SHARED && !defined NOT_IN_libc
  153. # define PTFAVAIL(NAME) __libc_pthread_functions_init
  154. # define __libc_ptf_call(FUNC, ARGS, ELSE) \
  155.   (__libc_pthread_functions_init ? PTHFCT_CALL (ptr_##FUNC, ARGS) : ELSE)
  156. # define __libc_ptf_call_always(FUNC, ARGS) \
  157.   PTHFCT_CALL (ptr_##FUNC, ARGS)
  158. #else
  159. # define PTFAVAIL(NAME) (NAME != NULL)
  160. # define __libc_ptf_call(FUNC, ARGS, ELSE) \
  161.   __libc_maybe_call (FUNC, ARGS, ELSE)
  162. # define __libc_ptf_call_always(FUNC, ARGS) \
  163.   FUNC ARGS
  164. #endif
  165.  
  166.  
  167. /* Initialize the named lock variable, leaving it in a consistent, unlocked
  168.    state.  */
  169. #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
  170. # define __libc_lock_init(NAME) ((NAME) = LLL_LOCK_INITIALIZER, 0)
  171. #else
  172. # define __libc_lock_init(NAME) \
  173.   __libc_maybe_call (__pthread_mutex_init, (&(NAME), NULL), 0)
  174. #endif
  175. #if defined SHARED && !defined NOT_IN_libc
  176. /* ((NAME) = (__libc_rwlock_t) PTHREAD_RWLOCK_INITIALIZER, 0) is
  177.    inefficient.  */
  178. # define __libc_rwlock_init(NAME) \
  179.   (__builtin_memset (&(NAME), '\0', sizeof (NAME)), 0)
  180. #else
  181. # define __libc_rwlock_init(NAME) \
  182.   __libc_maybe_call (__pthread_rwlock_init, (&(NAME), NULL), 0)
  183. #endif
  184.  
  185. /* Same as last but this time we initialize a recursive mutex.  */
  186. #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
  187. # define __libc_lock_init_recursive(NAME) \
  188.   ((NAME) = (__libc_lock_recursive_t) _LIBC_LOCK_RECURSIVE_INITIALIZER, 0)
  189. #else
  190. # define __libc_lock_init_recursive(NAME) \
  191.   do {                                          \
  192.     if (__pthread_mutex_init != NULL)                          \
  193.       {                                          \
  194.     pthread_mutexattr_t __attr;                          \
  195.     __pthread_mutexattr_init (&__attr);                      \
  196.     __pthread_mutexattr_settype (&__attr, PTHREAD_MUTEX_RECURSIVE_NP);    \
  197.     __pthread_mutex_init (&(NAME).mutex, &__attr);                  \
  198.     __pthread_mutexattr_destroy (&__attr);                      \
  199.       }                                          \
  200.   } while (0)
  201. #endif
  202.  
  203. #define __rtld_lock_init_recursive(NAME) \
  204.   do {                                          \
  205.     if (__pthread_mutex_init != NULL)                          \
  206.       {                                          \
  207.     pthread_mutexattr_t __attr;                          \
  208.     __pthread_mutexattr_init (&__attr);                      \
  209.     __pthread_mutexattr_settype (&__attr, PTHREAD_MUTEX_RECURSIVE_NP);    \
  210.     __pthread_mutex_init (&(NAME).mutex, &__attr);                  \
  211.     __pthread_mutexattr_destroy (&__attr);                      \
  212.       }                                          \
  213.   } while (0)
  214.  
  215. /* Finalize the named lock variable, which must be locked.  It cannot be
  216.    used again until __libc_lock_init is called again on it.  This must be
  217.    called on a lock variable before the containing storage is reused.  */
  218. #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
  219. # define __libc_lock_fini(NAME) ((void) 0)
  220. #else
  221. # define __libc_lock_fini(NAME) \
  222.   __libc_maybe_call (__pthread_mutex_destroy, (&(NAME)), 0)
  223. #endif
  224. #if defined SHARED && !defined NOT_IN_libc
  225. # define __libc_rwlock_fini(NAME) ((void) 0)
  226. #else
  227. # define __libc_rwlock_fini(NAME) \
  228.   __libc_maybe_call (__pthread_rwlock_destroy, (&(NAME)), 0)
  229. #endif
  230.  
  231. /* Finalize recursive named lock.  */
  232. #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
  233. # define __libc_lock_fini_recursive(NAME) ((void) 0)
  234. #else
  235. # define __libc_lock_fini_recursive(NAME) \
  236.   __libc_maybe_call (__pthread_mutex_destroy, (&(NAME)), 0)
  237. #endif
  238.  
  239. /* Lock the named lock variable.  */
  240. #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
  241. # define __libc_lock_lock(NAME) \
  242.   ({ lll_lock (NAME, LLL_PRIVATE); 0; })
  243. #else
  244. # define __libc_lock_lock(NAME) \
  245.   __libc_maybe_call (__pthread_mutex_lock, (&(NAME)), 0)
  246. #endif
  247. #define __libc_rwlock_rdlock(NAME) \
  248.   __libc_ptf_call (__pthread_rwlock_rdlock, (&(NAME)), 0)
  249. #define __libc_rwlock_wrlock(NAME) \
  250.   __libc_ptf_call (__pthread_rwlock_wrlock, (&(NAME)), 0)
  251.  
  252. /* Lock the recursive named lock variable.  */
  253. #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
  254. # define __libc_lock_lock_recursive(NAME) \
  255.   do {                                          \
  256.     void *self = THREAD_SELF;                              \
  257.     if ((NAME).owner != self)                              \
  258.       {                                          \
  259.     lll_lock ((NAME).lock, LLL_PRIVATE);                      \
  260.     (NAME).owner = self;                              \
  261.       }                                          \
  262.     ++(NAME).cnt;                                  \
  263.   } while (0)
  264. #else
  265. # define __libc_lock_lock_recursive(NAME) \
  266.   __libc_maybe_call (__pthread_mutex_lock, (&(NAME).mutex), 0)
  267. #endif
  268.  
  269. /* Try to lock the named lock variable.  */
  270. #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
  271. # define __libc_lock_trylock(NAME) \
  272.   lll_trylock (NAME)
  273. #else
  274. # define __libc_lock_trylock(NAME) \
  275.   __libc_maybe_call (__pthread_mutex_trylock, (&(NAME)), 0)
  276. #endif
  277. #define __libc_rwlock_tryrdlock(NAME) \
  278.   __libc_maybe_call (__pthread_rwlock_tryrdlock, (&(NAME)), 0)
  279. #define __libc_rwlock_trywrlock(NAME) \
  280.   __libc_maybe_call (__pthread_rwlock_trywrlock, (&(NAME)), 0)
  281.  
  282. /* Try to lock the recursive named lock variable.  */
  283. #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
  284. # define __libc_lock_trylock_recursive(NAME) \
  285.   ({                                          \
  286.     int result = 0;                                  \
  287.     void *self = THREAD_SELF;                              \
  288.     if ((NAME).owner != self)                              \
  289.       {                                          \
  290.     if (lll_trylock ((NAME).lock) == 0)                      \
  291.       {                                      \
  292.         (NAME).owner = self;                          \
  293.         (NAME).cnt = 1;                              \
  294.       }                                      \
  295.     else                                      \
  296.       result = EBUSY;                              \
  297.       }                                          \
  298.     else                                      \
  299.       ++(NAME).cnt;                                  \
  300.     result;                                      \
  301.   })
  302. #else
  303. # define __libc_lock_trylock_recursive(NAME) \
  304.   __libc_maybe_call (__pthread_mutex_trylock, (&(NAME)), 0)
  305. #endif
  306.  
  307. #define __rtld_lock_trylock_recursive(NAME) \
  308.   __libc_maybe_call (__pthread_mutex_trylock, (&(NAME).mutex), 0)
  309.  
  310. /* Unlock the named lock variable.  */
  311. #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
  312. # define __libc_lock_unlock(NAME) \
  313.   lll_unlock (NAME, LLL_PRIVATE)
  314. #else
  315. # define __libc_lock_unlock(NAME) \
  316.   __libc_maybe_call (__pthread_mutex_unlock, (&(NAME)), 0)
  317. #endif
  318. #define __libc_rwlock_unlock(NAME) \
  319.   __libc_ptf_call (__pthread_rwlock_unlock, (&(NAME)), 0)
  320.  
  321. /* Unlock the recursive named lock variable.  */
  322. #if defined _LIBC && (!defined NOT_IN_libc || defined IS_IN_libpthread)
  323. /* We do no error checking here.  */
  324. # define __libc_lock_unlock_recursive(NAME) \
  325.   do {                                          \
  326.     if (--(NAME).cnt == 0)                              \
  327.       {                                          \
  328.     (NAME).owner = NULL;                              \
  329.     lll_unlock ((NAME).lock, LLL_PRIVATE);                      \
  330.       }                                          \
  331.   } while (0)
  332. #else
  333. # define __libc_lock_unlock_recursive(NAME) \
  334.   __libc_maybe_call (__pthread_mutex_unlock, (&(NAME)), 0)
  335. #endif
  336.  
  337. #if defined _LIBC && defined SHARED
  338. # define __rtld_lock_default_lock_recursive(lock) \
  339.   ++((pthread_mutex_t *)(lock))->__data.__count;
  340.  
  341. # define __rtld_lock_default_unlock_recursive(lock) \
  342.   --((pthread_mutex_t *)(lock))->__data.__count;
  343.  
  344. # define __rtld_lock_lock_recursive(NAME) \
  345.   GL(dl_rtld_lock_recursive) (&(NAME).mutex)
  346.  
  347. # define __rtld_lock_unlock_recursive(NAME) \
  348.   GL(dl_rtld_unlock_recursive) (&(NAME).mutex)
  349. #else
  350. # define __rtld_lock_lock_recursive(NAME) \
  351.   __libc_maybe_call (__pthread_mutex_lock, (&(NAME).mutex), 0)
  352.  
  353. # define __rtld_lock_unlock_recursive(NAME) \
  354.   __libc_maybe_call (__pthread_mutex_unlock, (&(NAME).mutex), 0)
  355. #endif
  356.  
  357. /* Define once control variable.  */
  358. #if PTHREAD_ONCE_INIT == 0
  359. /* Special case for static variables where we can avoid the initialization
  360.    if it is zero.  */
  361. # define __libc_once_define(CLASS, NAME) \
  362.   CLASS pthread_once_t NAME
  363. #else
  364. # define __libc_once_define(CLASS, NAME) \
  365.   CLASS pthread_once_t NAME = PTHREAD_ONCE_INIT
  366. #endif
  367.  
  368. /* Call handler iff the first call.  */
  369. #define __libc_once(ONCE_CONTROL, INIT_FUNCTION) \
  370.   do {                                          \
  371.     if (PTFAVAIL (__pthread_once))                          \
  372.       __libc_ptf_call_always (__pthread_once, (&(ONCE_CONTROL),              \
  373.                            INIT_FUNCTION));              \
  374.     else if ((ONCE_CONTROL) == PTHREAD_ONCE_INIT) {                  \
  375.       INIT_FUNCTION ();                                  \
  376.       (ONCE_CONTROL) |= 2;                              \
  377.     }                                          \
  378.   } while (0)
  379.  
  380.  
  381. /* Note that for I/O cleanup handling we are using the old-style
  382.    cancel handling.  It does not have to be integrated with C++ snce
  383.    no C++ code is called in the middle.  The old-style handling is
  384.    faster and the support is not going away.  */
  385. extern void _pthread_cleanup_push (struct _pthread_cleanup_buffer *buffer,
  386.                                    void (*routine) (void *), void *arg);
  387. extern void _pthread_cleanup_pop (struct _pthread_cleanup_buffer *buffer,
  388.                                   int execute);
  389. extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *buffer,
  390.                                          void (*routine) (void *), void *arg);
  391. extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *buffer,
  392.                                           int execute);
  393.  
  394. /* Start critical region with cleanup.  */
  395. #define __libc_cleanup_region_start(DOIT, FCT, ARG) \
  396.   { struct _pthread_cleanup_buffer _buffer;                      \
  397.     int _avail;                                      \
  398.     if (DOIT) {                                      \
  399.       _avail = PTFAVAIL (_pthread_cleanup_push_defer);                  \
  400.       if (_avail) {                                  \
  401.     __libc_ptf_call_always (_pthread_cleanup_push_defer, (&_buffer, FCT,  \
  402.                                   ARG));          \
  403.       } else {                                      \
  404.     _buffer.__routine = (FCT);                          \
  405.     _buffer.__arg = (ARG);                              \
  406.       }                                          \
  407.     } else {                                      \
  408.       _avail = 0;                                  \
  409.     }
  410.  
  411. /* End critical region with cleanup.  */
  412. #define __libc_cleanup_region_end(DOIT) \
  413.     if (_avail) {                                  \
  414.       __libc_ptf_call_always (_pthread_cleanup_pop_restore, (&_buffer, DOIT));\
  415.     } else if (DOIT)                                  \
  416.       _buffer.__routine (_buffer.__arg);                      \
  417.   }
  418.  
  419. /* Sometimes we have to exit the block in the middle.  */
  420. #define __libc_cleanup_end(DOIT) \
  421.     if (_avail) {                                  \
  422.       __libc_ptf_call_always (_pthread_cleanup_pop_restore, (&_buffer, DOIT));\
  423.     } else if (DOIT)                                  \
  424.       _buffer.__routine (_buffer.__arg)
  425.  
  426.  
  427. /* Normal cleanup handling, based on C cleanup attribute.  */
  428. __extern_inline void
  429. __libc_cleanup_routine (struct __pthread_cleanup_frame *f)
  430. {
  431.   if (f->__do_it)
  432.     f->__cancel_routine (f->__cancel_arg);
  433. }
  434.  
  435. #define __libc_cleanup_push(fct, arg) \
  436.   do {                                          \
  437.     struct __pthread_cleanup_frame __clframe                      \
  438.       __attribute__ ((__cleanup__ (__libc_cleanup_routine)))              \
  439.       = { .__cancel_routine = (fct), .__cancel_arg = (arg),              \
  440.           .__do_it = 1 };
  441.  
  442. #define __libc_cleanup_pop(execute) \
  443.     __clframe.__do_it = (execute);                          \
  444.   } while (0)
  445.  
  446.  
  447. /* Create thread-specific key.  */
  448. #define __libc_key_create(KEY, DESTRUCTOR) \
  449.   __libc_ptf_call (__pthread_key_create, (KEY, DESTRUCTOR), 1)
  450.  
  451. /* Get thread-specific data.  */
  452. #define __libc_getspecific(KEY) \
  453.   __libc_ptf_call (__pthread_getspecific, (KEY), NULL)
  454.  
  455. /* Set thread-specific data.  */
  456. #define __libc_setspecific(KEY, VALUE) \
  457.   __libc_ptf_call (__pthread_setspecific, (KEY, VALUE), 0)
  458.  
  459.  
  460. /* Register handlers to execute before and after `fork'.  Note that the
  461.    last parameter is NULL.  The handlers registered by the libc are
  462.    never removed so this is OK.  */
  463. #define __libc_atfork(PREPARE, PARENT, CHILD) \
  464.   __register_atfork (PREPARE, PARENT, CHILD, NULL)
  465. extern int __register_atfork (void (*__prepare) (void),
  466.                   void (*__parent) (void),
  467.                   void (*__child) (void),
  468.                   void *__dso_handle);
  469.  
  470. /* Functions that are used by this file and are internal to the GNU C
  471.    library.  */
  472.  
  473. extern int __pthread_mutex_init (pthread_mutex_t *__mutex,
  474.                  __const pthread_mutexattr_t *__mutex_attr);
  475.  
  476. extern int __pthread_mutex_destroy (pthread_mutex_t *__mutex);
  477.  
  478. extern int __pthread_mutex_trylock (pthread_mutex_t *__mutex);
  479.  
  480. extern int __pthread_mutex_lock (pthread_mutex_t *__mutex);
  481.  
  482. extern int __pthread_mutex_unlock (pthread_mutex_t *__mutex);
  483.  
  484. extern int __pthread_mutexattr_init (pthread_mutexattr_t *__attr);
  485.  
  486. extern int __pthread_mutexattr_destroy (pthread_mutexattr_t *__attr);
  487.  
  488. extern int __pthread_mutexattr_settype (pthread_mutexattr_t *__attr,
  489.                     int __kind);
  490.  
  491. #ifdef __USE_UNIX98
  492. extern int __pthread_rwlock_init (pthread_rwlock_t *__rwlock,
  493.                   __const pthread_rwlockattr_t *__attr);
  494.  
  495. extern int __pthread_rwlock_destroy (pthread_rwlock_t *__rwlock);
  496.  
  497. extern int __pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock);
  498.  
  499. extern int __pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock);
  500.  
  501. extern int __pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock);
  502.  
  503. extern int __pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock);
  504.  
  505. extern int __pthread_rwlock_unlock (pthread_rwlock_t *__rwlock);
  506. #endif
  507.  
  508. extern int __pthread_key_create (pthread_key_t *__key,
  509.                  void (*__destr_function) (void *));
  510.  
  511. extern int __pthread_setspecific (pthread_key_t __key,
  512.                   __const void *__pointer);
  513.  
  514. extern void *__pthread_getspecific (pthread_key_t __key);
  515.  
  516. extern int __pthread_once (pthread_once_t *__once_control,
  517.                void (*__init_routine) (void));
  518.  
  519. extern int __pthread_atfork (void (*__prepare) (void),
  520.                  void (*__parent) (void),
  521.                  void (*__child) (void));
  522.  
  523.  
  524.  
  525. /* Make the pthread functions weak so that we can elide them from
  526.    single-threaded processes.  */
  527. #ifndef __NO_WEAK_PTHREAD_ALIASES
  528. # ifdef weak_extern
  529. #  if _LIBC
  530. #   include <bp-sym.h>
  531. #  else
  532. #   define BP_SYM (sym) sym
  533. #  endif
  534. weak_extern (BP_SYM (__pthread_mutex_init))
  535. weak_extern (BP_SYM (__pthread_mutex_destroy))
  536. weak_extern (BP_SYM (__pthread_mutex_lock))
  537. weak_extern (BP_SYM (__pthread_mutex_trylock))
  538. weak_extern (BP_SYM (__pthread_mutex_unlock))
  539. weak_extern (BP_SYM (__pthread_mutexattr_init))
  540. weak_extern (BP_SYM (__pthread_mutexattr_destroy))
  541. weak_extern (BP_SYM (__pthread_mutexattr_settype))
  542. weak_extern (BP_SYM (__pthread_rwlock_init))
  543. weak_extern (BP_SYM (__pthread_rwlock_destroy))
  544. weak_extern (BP_SYM (__pthread_rwlock_rdlock))
  545. weak_extern (BP_SYM (__pthread_rwlock_tryrdlock))
  546. weak_extern (BP_SYM (__pthread_rwlock_wrlock))
  547. weak_extern (BP_SYM (__pthread_rwlock_trywrlock))
  548. weak_extern (BP_SYM (__pthread_rwlock_unlock))
  549. weak_extern (BP_SYM (__pthread_key_create))
  550. weak_extern (BP_SYM (__pthread_setspecific))
  551. weak_extern (BP_SYM (__pthread_getspecific))
  552. weak_extern (BP_SYM (__pthread_once))
  553. weak_extern (__pthread_initialize)
  554. weak_extern (__pthread_atfork)
  555. weak_extern (BP_SYM (_pthread_cleanup_push_defer))
  556. weak_extern (BP_SYM (_pthread_cleanup_pop_restore))
  557. weak_extern (BP_SYM (pthread_setcancelstate))
  558. # else
  559. #  pragma weak __pthread_mutex_init
  560. #  pragma weak __pthread_mutex_destroy
  561. #  pragma weak __pthread_mutex_lock
  562. #  pragma weak __pthread_mutex_trylock
  563. #  pragma weak __pthread_mutex_unlock
  564. #  pragma weak __pthread_mutexattr_init
  565. #  pragma weak __pthread_mutexattr_destroy
  566. #  pragma weak __pthread_mutexattr_settype
  567. #  pragma weak __pthread_rwlock_destroy
  568. #  pragma weak __pthread_rwlock_rdlock
  569. #  pragma weak __pthread_rwlock_tryrdlock
  570. #  pragma weak __pthread_rwlock_wrlock
  571. #  pragma weak __pthread_rwlock_trywrlock
  572. #  pragma weak __pthread_rwlock_unlock
  573. #  pragma weak __pthread_key_create
  574. #  pragma weak __pthread_setspecific
  575. #  pragma weak __pthread_getspecific
  576. #  pragma weak __pthread_once
  577. #  pragma weak __pthread_initialize
  578. #  pragma weak __pthread_atfork
  579. #  pragma weak _pthread_cleanup_push_defer
  580. #  pragma weak _pthread_cleanup_pop_restore
  581. #  pragma weak pthread_setcancelstate
  582. # endif
  583. #endif
  584.  
  585. #endif    /* bits/libc-lock.h */
  586.